package com.linyu.huawei.simple;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * BracketsCheck
 * 2023A-括号检查
 *
 * @author 23087
 * @since 2024/11/29
 */
public class BracketsCheck {

        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String s = scanner.nextLine();
            // 初始化用于判断异常的变量isError，初始化为False表示没有异常
            boolean isError = false;
            // 初始化答案变量ans和记录当前深度的变量cur_depth
            int ans = 0;
            int cur_depth = 0;
            // 构建三种括号的两两配对关系
            List<Character[]> pairs = new ArrayList<>();
            pairs.add(new Character[]{'(', ')'});
            pairs.add(new Character[]{'{', '}'});
            pairs.add(new Character[]{'[', ']'});

            // 若字符串长度为奇数，必定无法配对，isError设置为True
            if (s.length() % 2 == 1) {
                isError = true;
            } else {
                // 使用列表list初始化一个空栈
                List<Character> stack = new ArrayList<>();
                // 一次遍历字符串s中的每一个字符ch
                for (char ch : s.toCharArray()) {
                    // 若ch为某种左括号
                    if (ch == '(' || ch == '{' || ch == '[') {
                        // 则将ch加入栈顶，同时括号深度+1，更新最大括号深度
                        stack.add(ch);
                        cur_depth++;
                        ans = Math.max(ans, cur_depth);
                    } else {
                        // 若此时栈为空
                        if (stack.isEmpty()) {
                            // 该右括号无法与左括号配对，出现异常，isError设置为True，同时退出循环
                            isError = true;
                            break;
                        }
                        // 若栈不为空，则弹出栈顶字符，同时括号深度-1
                        char ch_stack_top = stack.remove(stack.size() - 1);
                        cur_depth--;
                        // 若栈顶左括号字符ch_stack_top和当前右括号字符ch不配对，
                        // 出现异常，isError设置为True，同时退出循环
                        boolean isPair = false;
                        for (Character[] pair : pairs) {
                            if (pair[0] == ch_stack_top && pair[1] == ch) {
                                isPair = true;
                                break;
                            }
                        }
                        if (!isPair) {
                            isError = true;
                            break;
                        }
                    }
                }
                // 经过一次遍历后，若仍存在元素，说明存在括号未配对，出现异常，isError设置为True
                if (!stack.isEmpty()) {
                    isError = true;
                }
            }

            // 如果isError标志为True，说明前面某一步出现异常，输出0，否则输出最大深度ans
            System.out.println(isError ? 0 : ans);
        }


}